Effective Java 2.0_中英文对照_Item 3

| |
Effective Java 2.0_Item3

文章作者：Tyan
博客：noahsnail.com  |  CSDN  |  简书

Item 3 Enforce the singleton property with a private constructor or an enum type

A singleton is simply a class that is instantiated exactly once [Gamma95, p. 127]. Singletons typically represent a system component that is intrinsically unique, such as the window manager or file system. Making a class a singleton can make it difficult to test its clients, as it’s impossible to substitute a mock implementation for a singleton unless it implements an interface that serves as its type.

单例简单来说就是一个类只被实例化一次[Gamma95, p. 127]。通常单例表示一个系统组件在本质上来说是唯一的，例如窗口管理或文件系统。一个类成为单例会使它的客户端测试变得很困难，因为不可能用伪实现来代替单例，除非它实现了一个接口，这个接口作为它的服务类型。

Before release 1.5, there were two ways to implement singletons. Both are based on keeping the constructor private and exporting a public static member to provide access to the sole instance. In one approach, the member is a final field:

在1.5版本之前，有两种方式来实现单例。它们都是通过保持私有构造函数并输出一个公有静态成员来提供对类唯一实例的访问来实现的。在第一种方法中，公有静态成员被声明为final变量：

1
2
3
4
5
6
// Singleton with public final field
public class Elvis {
    public static final Elvis INSTANCE = new Elvis();
    private Elvis() { ... }
    public void leaveTheBuilding() { ... }
}

The private constructor is called only once, to initialize the public static final field Elvis.INSTANCE. The lack of a public or protected constructor guarantees a “monoelvistic” universe: exactly one Elvis instance will exist once the Elvis class is initialized—-no more, no less. Nothing that a client does can change this, with one caveat: a privileged client can invoke the private constructor reflectively (Item 53) with the aid of the AccessibleObject.setAccessible method. If you need to defend against this attack, modify the constructor to make it throw an exception if it’s asked to create a second instance.

为了初始化公有静态final变量Elvis.INSTANCE，私有构造函数只调用一次。公有或保护构造函数的缺失保证了全局唯一性：确切的说一旦Elvis类初始化，将只有一个Elvis实例存在——不会多也不会少。客户端不能改变这个情况，但要提醒一点：有特权的客户端可以借用AccessibleObject.setAccessible方法方法，通过反射机制（Item 53）的调用私有构造函数。如果你需要抵御这种攻击，修改构造函数使它在创建第二个实例时抛出异常。

In the second approach to implementing singletons, the public member is a static factory method:

在第二种实现单例的方法中，公有成员是一个静态工厂方法：

1
2
3
4
5
6
// Singleton with static factory
public class Elvis {
	private static final Elvis INSTANCE = new Elvis(); private Elvis() { ... }
	public static Elvis getInstance() { return INSTANCE; }
    public void leaveTheBuilding() { ... }
}

All calls to Elvis.getInstance return the same object reference, and no other Elvis instance will ever be created (with the same caveat mentioned above).

所有Elvis.getInstance方法的调用都会返回同一个对象实例，并且不会有其它的Elvis实例被创建（提醒同上）。

The main advantage of the public field approach is that the declarations make it clear that the class is a singleton: the public static field is final, so it will always contain the same object reference. There is no longer any performance advantage to the public field approach: modern Java virtual machine (JVM) implementations are almost certain to inline the call to the static factory method.

公有变量方法的主要优势在于更清晰的声明这个类是一个单例类：公有静态变量是final的，因此它总是包含同一个对象的引用。公有变量方法没有任何性能优势：现代Java虚拟机（JVM）的大多数实现都是将静态工厂方法当做内联函数来调用。

One advantage of the factory-method approach is that it gives you the flexibility to change your mind about whether the class should be a singleton without changing its API. The factory method returns the sole instance but could easily be modified to return, say, a unique instance for each thread that invokes it. A second advantage, concerning generic types, is discussed in Item 27. Often neither of these advantages is relevant, and the final-field approach is simpler.

工厂方法的一个优势在于你可以灵活的改变你的想法，无论类是否是单例你都不必修改它的API。工厂方法返回唯一的实例，但它很容易被修改成为每个调用它的线程都返回一个唯一的实例。第二个优势是关于泛型的，在Item 27讨论。这些优势往往都是相关的，final变量方法更简单。

To make a singleton class that is implemented using either of the previous approaches serializable (Chapter 11), it is not sufficient merely to add implements Serializable to its declaration. To maintain the singleton guarantee, you have to declare all instance fields transient and provide a readResolve method (Item 77). Otherwise, each time a serialized instance is deserialized, a new instance will be created, leading, in the case of our example, to spurious Elvis sightings. To prevent this, add this readResolve method to the Elvis class:

为了使上面方法实现的单例类可序列化（第11章），仅仅在它的声明中实现Serializable接口是不够的。为了保证单例性，你必须将所有的实例变量声明为transient并提供一个readResolve方法（Item 77）。否则，每次一个序列化的实例在反序列化时将会创建一个新的实例，在我们的例子中，会看到一个假的Elvis。为了防止这种情况发生，要在Elvis类中添加readResolve方法：

1
2
3
4
5
6
// readResolve method to preserve singleton property
   private Object readResolve() {
        // Return the one true Elvis and let the garbage collector
        // take care of the Elvis impersonator.
       return INSTANCE;
   }

As of release 1.5, there is a third approach to implementing singletons. Simply make an enum type with one element:

在1.5版本中，有第三种实现单例的方法。简单声明一个只有一个元素的枚举类型：

1
2
3
4
5
// Enum singleton - the preferred approach
   public enum Elvis {
       INSTANCE;
       public void leaveTheBuilding() { ... }
   }

This approach is functionally equivalent to the public field approach, except that it is more concise, provides the serialization machinery for free, and provides an ironclad guarantee against multiple instantiation, even in the face of sophisticated serialization or reflection attacks. While this approach has yet to be widely adopted, a single-element enum type is the best way to implement a singleton.

这个方法除了它更简洁之外，它在功能上等价于公有变量方法，免费提供了序列化机制，并且强有力的保证了不会被多次实例化，即使是在面临复杂的序列化或反射攻击时。虽然这个方法仍没有被广泛采用，但单元素的枚举类型是实现单例的最好方式。

如果有收获，可以请我喝杯咖啡！